components/Calendar.tsx (1)

54-54: Trim trailing whitespace.

Minor tidy-up.

-              </div>  
+              </div>

scripts/index.ts (1)

37-38: Consider isolating LLMS generation failures from the main build.

Optional guard so docs build isn’t blocked by non-critical LLMS outputs.

-  await buildLlmsTxt();
-  await buildLlmsFull();
+  try {
+    await buildLlmsTxt();
+    await buildLlmsFull();
+  } catch (err) {
+    console.error('LLMS build failed:', err);
+  }

Configuration used: Path: .coderabbit.yaml

Review profile: CHILL

Plan: Pro

Learnt from: akshatnema
PR: asyncapi/website#3101
File: scripts/build-rss.js:4-6
Timestamp: 2024-11-01T09:35:23.912Z
Learning: Converting `getAllPosts()` to asynchronous in `scripts/build-rss.js` causes the existing build system to fail.

Learnt from: vishvamsinh28
PR: asyncapi/website#3284
File: scripts/build-post-list.js:49-53
Timestamp: 2024-11-10T18:16:22.273Z
Learning: In `scripts/build-post-list.js`, the `walkDirectories` function depends on sequential execution because it mutates `resultObj`. Parallelizing the loop with `Promise.all` causes tests to fail.

scripts/build-llms-full.ts (3)

9-12: Fix JSON import: replace dynamic JSON import with fs+path (avoids ESM JSON import and bundler pitfalls).

Dynamic import('../config/posts.json') commonly fails in CI/tests (needs assert { type: 'json' }, bundler hooks, or experimental flags). Read via FS with an absolute path.

Apply:

-import fs from 'fs';
+import { promises as fs } from 'node:fs';
+import { dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
@@
-async function getAllPosts(): Promise<Result> {
-  const posts = (await import('../config/posts.json')).default as Result;
-  return posts;
-}
+async function getAllPosts(): Promise<Result> {
+  const __filename = fileURLToPath(import.meta.url);
+  const __dirname = dirname(__filename);
+  const jsonPath = resolve(__dirname, '../config/posts.json');
+  const raw = await fs.readFile(jsonPath, 'utf8');
+  return JSON.parse(raw) as Result;
+}

Also applies to: 1-2

---

135-144: Fix “Total URLs” undercount; write asynchronously and ensure ./public exists; make output path CWD‑safe.

Current count is computed before the final block and sync write may race/build stall; also missing mkdir. Compute after assembling, append, mkdir -p, and write via async API using a path relative to this file.

-# END OF RESOURCE LIST
-# Total URLs: ${content.split('\n').filter(line => line.includes('http')).length}
-`;
-
-  // Write the file
-  fs.writeFileSync('./public/llms-full.txt', content, 'utf8');
-  
-  const urlCount = content.split('\n').filter(line => line.includes('http')).length;
-  console.log(`✅ llms-full.txt generated successfully with ${urlCount} URLs at ./public/llms-full.txt`);
+# END OF RESOURCE LIST
+`;
+
+  // Compute final URL count and append
+  const urlCount = content
+    .split('\n')
+    .filter((line) => /^https?:\/\//.test(line.trim()))
+    .length;
+  content += `# Total URLs: ${urlCount}\n`;
+
+  // Ensure output dir and write (path resolved relative to this file)
+  const __filename = fileURLToPath(import.meta.url);
+  const __dirname = dirname(__filename);
+  const outDir = resolve(__dirname, '../public');
+  const outFile = resolve(outDir, 'llms-full.txt');
+  await fs.mkdir(outDir, { recursive: true });
+  await fs.writeFile(outFile, content, 'utf8');
+  console.log(`✅ llms-full.txt generated successfully with ${urlCount} URLs at ${outFile}`);

Also applies to: 60-60

---

91-103: Guard non-array post types and skip docsTree.

Prevents accidental inclusion of nav trees/objects.

-  Object.keys(posts).forEach(postType => {
-    if (!['docs', 'blog', 'about'].includes(postType)) {
-      const postArray = (posts as any)[postType];
-      if (postArray && postArray.length > 0) {
+  Object.keys(posts).forEach((postType) => {
+    if (!['docs', 'blog', 'about', 'docsTree'].includes(postType)) {
+      const postArray = (posts as any)[postType];
+      if (Array.isArray(postArray) && postArray.length > 0) {
         const sectionTitle = postType.charAt(0).toUpperCase() + postType.slice(1);
         content += `\n## ${sectionTitle}\n`;
         postArray.forEach((item: any) => {
           content += `${base}${item.slug} - ${item.title}\n`;
         });
       }
     }
   });

scripts/build-llms-full.ts (4)

72-81: Harden blog sorting for missing/invalid dates.

new Date(x).getTime() can be NaN, making comparator unstable.

-    posts.blog
-      .sort((a: any, b: any) => new Date(b.date).getTime() - new Date(a.date).getTime())
+    posts.blog
+      .sort((a: any, b: any) => {
+        const tb = Date.parse(b?.date ?? '');
+        const ta = Date.parse(a?.date ?? '');
+        return (isNaN(tb) ? 0 : tb) - (isNaN(ta) ? 0 : ta); // desc
+      })
       .forEach((post: any) => {
-        const date = post.date ? ` (${post.date.split('T')[0]})` : '';
+        const date =
+          post?.date && !isNaN(Date.parse(post.date))
+            ? ` (${new Date(post.date).toISOString().split('T')[0]})`
+            : ''
         content += `${base}${post.slug} - ${post.title}${date}\n`;
       });

---

31-31: Make base URL configurable (works in previews and local runs).

-  const base = 'https://www.asyncapi.com';
+  const base = (process.env.SITE_URL ?? 'https://www.asyncapi.com').replace(/\/$/, '');

---

127-129: Correct v2 vs v3 note for accuracy.

v2 already has channels; the change is how operations are modeled.

-# v3.0 uses 'channels' and 'operations' objects instead of v2's inline channel definitions
+# In v2, operations live inline on each channel item via `publish`/`subscribe`.
+# In v3.0, operations are first-class under a top-level `operations` object and channels reference them.

---

65-69: Optional: remove any by using the Details type for stronger checks.

-      .forEach((doc: any) => {
+      .forEach((doc: { slug: string; title: string }) => {
         content += `${base}${doc.slug} - ${doc.title}\n`;
       });
@@
-      .forEach((post: any) => {
+      .forEach((post: { slug: string; title: string; date?: string }) => {
         const date = post.date ? ` (${post.date.split('T')[0]})` : '';
         content += `${base}${post.slug} - ${post.title}${date}\n`;
       });
@@
-    posts.about.forEach((page: any) => {
+    posts.about.forEach((page: { slug: string; title: string }) => {
       content += `${base}${page.slug} - ${page.title}\n`;
     });
@@
-        postArray.forEach((item: any) => {
+        postArray.forEach((item: { slug: string; title: string }) => {
           content += `${base}${item.slug} - ${item.title}\n`;
         });

Also applies to: 75-80, 86-88, 98-100

Configuration used: Path: .coderabbit.yaml

Review profile: CHILL

Plan: Pro

Learnt from: akshatnema
PR: asyncapi/website#3101
File: scripts/build-rss.js:4-6
Timestamp: 2024-11-01T09:35:23.912Z
Learning: Converting `getAllPosts()` to asynchronous in `scripts/build-rss.js` causes the existing build system to fail.

Learnt from: akshatnema
PR: asyncapi/website#3423
File: tests/index.test.js:2-7
Timestamp: 2025-01-18T08:44:43.614Z
Learning: In the AsyncAPI website project, JavaScript test files must include the .ts extension when importing TypeScript files (e.g., `require('../scripts/build-rss.ts')`). This is enforced by the project's configuration which uses `moduleResolution: "bundler"` in tsconfig.json and TypeScript-aware ESLint plugins. The .ts extensions are required even though the files are imported using CommonJS require statements.

Learnt from: vishvamsinh28
PR: asyncapi/website#3284
File: scripts/build-post-list.js:49-53
Timestamp: 2024-11-10T18:16:22.273Z
Learning: In `scripts/build-post-list.js`, the `walkDirectories` function depends on sequential execution because it mutates `resultObj`. Parallelizing the loop with `Promise.all` causes tests to fail.

Learnt from: akshatnema
PR: asyncapi/website#3423
File: tests/index.test.js:2-7
Timestamp: 2025-01-18T08:44:43.614Z
Learning: In the AsyncAPI website project, JavaScript test files must include the .ts extension when importing TypeScript files (e.g., `require('../scripts/build-rss.ts')`). This is a project-specific requirement enforced by the linting rules and build setup, even though it differs from typical Node.js behavior.

components/Calendar.tsx (3)

50-50: Strip trailing whitespace to satisfy linters

Extraneous spaces after the closing div can trip formatters.

-              </div>  
+              </div>

---

32-33: Potential runtime crash when eventsData is undefined

eventsData?.filter(...).length can throw because .length is accessed on undefined when eventsData is absent. Use .some() with nullish coalescing.

-  const eventsExist = eventsData?.filter((event: IEvent) => moment(event.date).isAfter(currentDate)).length > 0;
+  const eventsExist = eventsData?.some((event: IEvent) => moment(event.date).isAfter(currentDate)) ?? false;

---

46-46: Avoid array index as React key

Use a stable, unique key to prevent reconciliation bugs.

-          <li key={index} data-testid='Calendar-list-item'>
+          <li key={event.url || `${event.date}-${index}`} data-testid='Calendar-list-item'>

Configuration used: Path: .coderabbit.yaml

Review profile: CHILL

Plan: Pro

scripts/build-llms.ts (1)

53-56: Async FS + mkdir — resolved.

You switched to async fs and ensure ./public exists. This addresses the earlier ENOENT/blocking I/O concern.

scripts/build-llms-full.ts (1)

11-17: Good: robust FS + absolute path for posts.json.

Switching from dynamic import to fs+path fixes ModuleNotFoundError in tests/build.

scripts/build-llms.ts (3)

18-18: Allow base URL override (keep canonical as default).

Make the base host configurable for previews/self-hosts while defaulting to asyncapi.com.

Apply:

-  const base = 'https://www.asyncapi.com';
+  const base = (process.env.SITE_URL || 'https://www.asyncapi.com').replace(/\/$/, '');

---

29-33: Prefer docs site for spec reference (GitHub branch can drift).

Add the v3 docs reference (keep GitHub as secondary if you want).

 ## Specifications & Schemas  
 ${base}/definitions/3.0.0/asyncapi.json - AsyncAPI 3.0.0 JSON Schema
 ${base}/definitions/2.6.0/asyncapi.json - AsyncAPI 2.6.0 JSON Schema
-https://github.com/asyncapi/spec/blob/master/spec/asyncapi.md - Latest specification
+${base}/docs/reference/specification/v3.0.0 - Latest specification ( docs )
+https://github.com/asyncapi/spec - Specification source ( GitHub )

---

1-1: Minor: use node:fs/promises and absolute output path (CWD‑safe).

Avoid CWD assumptions and use the promises module directly.

-import fs from 'fs';
+import { mkdir, writeFile } from 'node:fs/promises';
+import { resolve, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
@@
-  await fs.promises.mkdir('./public', { recursive: true });
-  await fs.promises.writeFile('./public/llms.txt', llmsContent, 'utf8');
+  const __filename = fileURLToPath(import.meta.url);
+  const __dirname = dirname(__filename);
+  const outDir = resolve(__dirname, '../public');
+  const outFile = resolve(outDir, 'llms.txt');
+  await mkdir(outDir, { recursive: true });
+  await writeFile(outFile, llmsContent, 'utf8');

Also applies to: 54-55

scripts/build-llms-full.ts (4)

79-85: Guard against invalid/missing blog dates in sort.

If a post lacks a valid date, the comparator can return NaN leading to unstable order.

-      .sort((a: any, b: any) => new Date(b.date).getTime() - new Date(a.date).getTime())
+      .sort((a: any, b: any) => {
+        const ta = Number.isFinite(new Date(a?.date ?? '').getTime()) ? new Date(a.date).getTime() : 0;
+        const tb = Number.isFinite(new Date(b?.date ?? '').getTime()) ? new Date(b.date).getTime() : 0;
+        return tb - ta;
+      })

---

110-120: Use stable join link for Slack.

Workspaces URLs can require auth; prefer the public join URL on the site.

-https://asyncapi.slack.com - Official Slack community
+${base}/slack - Official Slack community

---

143-146: Count URLs precisely (not just lines containing “http”).

This avoids under/over‑count and is resilient if multiple URLs appear on a line.

-  const urlCount = content.split('\n').filter((line) => line.includes('http')).length;
+  const urlCount = (content.match(/https?:\/\/\S+/g) || []).length;

---

147-150: CWD‑independent output path.

Resolve ./public relative to this script to avoid surprises in different runners.

-  await fs.promises.mkdir('./public', { recursive: true });
-  await fs.promises.writeFile('./public/llms-full.txt', content, 'utf8');
-  console.log(`✅ llms-full.txt generated successfully with ${urlCount} URLs at ./public/llms-full.txt`);
+  const outDir = resolve(dirname(fileURLToPath(import.meta.url)), '../public');
+  const outFile = resolve(outDir, 'llms-full.txt');
+  await fs.promises.mkdir(outDir, { recursive: true });
+  await fs.promises.writeFile(outFile, content, 'utf8');
+  console.log(`✅ llms-full.txt generated successfully with ${urlCount} URLs at ${outFile}`);

Configuration used: Path: .coderabbit.yaml

Review profile: CHILL

Plan: Pro

Learnt from: akshatnema
PR: asyncapi/website#3101
File: scripts/build-rss.js:4-6
Timestamp: 2024-11-01T09:35:23.912Z
Learning: Converting `getAllPosts()` to asynchronous in `scripts/build-rss.js` causes the existing build system to fail.

Learnt from: akshatnema
PR: asyncapi/website#3423
File: tests/index.test.js:2-7
Timestamp: 2025-01-18T08:44:43.614Z
Learning: In the AsyncAPI website project, JavaScript test files must include the .ts extension when importing TypeScript files (e.g., `require('../scripts/build-rss.ts')`). This is enforced by the project's configuration which uses `moduleResolution: "bundler"` in tsconfig.json and TypeScript-aware ESLint plugins. The .ts extensions are required even though the files are imported using CommonJS require statements.

Learnt from: vishvamsinh28
PR: asyncapi/website#3284
File: scripts/build-post-list.js:49-53
Timestamp: 2024-11-10T18:16:22.273Z
Learning: In `scripts/build-post-list.js`, the `walkDirectories` function depends on sequential execution because it mutates `resultObj`. Parallelizing the loop with `Promise.all` causes tests to fail.

Learnt from: akshatnema
PR: asyncapi/website#3423
File: tests/index.test.js:2-7
Timestamp: 2025-01-18T08:44:43.614Z
Learning: In the AsyncAPI website project, JavaScript test files must include the .ts extension when importing TypeScript files (e.g., `require('../scripts/build-rss.ts')`). This is a project-specific requirement enforced by the linting rules and build setup, even though it differs from typical Node.js behavior.

scripts/build-llms-full.ts (11)

1-4: Prefer node: specifiers and fs.promises for clarity and ESM correctness.

Use built‑in module specifiers and import promises API directly; simplifies calls and avoids CJS interop edge cases.

-import fs from 'fs';
-import type { Result } from '@/types/scripts/build-posts-list';
-import { dirname, resolve } from 'path';
+import { promises as fs } from 'node:fs';
+import type { Result } from '@/types/scripts/build-posts-list';
+import { dirname, resolve } from 'node:path';
 import { fileURLToPath } from 'url';

And update below:

-  const raw = await fs.promises.readFile(jsonPath, 'utf8');
+  const raw = await fs.readFile(jsonPath, 'utf8');

-  await fs.promises.mkdir('./public', { recursive: true });
-  await fs.promises.writeFile('./public/llms-full.txt', content, 'utf8');
+  await fs.mkdir(outDir, { recursive: true });
+  await fs.writeFile(outPath, content, 'utf8');

---

11-17: Harden read/parse with actionable error messages.

Wrap IO/JSON parse to aid CI debugging.

 async function getAllPosts(): Promise<Result> {
   const __filename = fileURLToPath(import.meta.url);
   const __dirname = dirname(__filename);
   const jsonPath = resolve(__dirname, '../config/posts.json');
-  const raw = await fs.promises.readFile(jsonPath, 'utf8');
-  return JSON.parse(raw) as Result;
+  try {
+    const raw = await fs.readFile(jsonPath, 'utf8');
+    return JSON.parse(raw) as Result;
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    throw new Error(`Failed to read/parse posts.json at ${jsonPath}: ${msg}`);
+  }
 }

Does this script also run from your compiled output (if you compile scripts), or only via tsx/ts-node? If compiled, confirm that ../config/posts.json is available relative to the emitted scripts.

---

33-38: Make base URL configurable to support previews/staging.

Allow override via env while defaulting to production.

-export async function buildLlmsFull(): Promise<void> {
+export async function buildLlmsFull(): Promise<void> {
   console.log('Building llms-full.txt...');
   
-  const base = 'https://www.asyncapi.com';
+  const base = (process.env.SITE_URL || 'https://www.asyncapi.com').replace(/\/$/, '');
   const posts = await getAllPosts();

Set SITE_URL in Netlify/Vercel preview so links match the deploy-preview domain if desired.

---

45-51: Avoid hard‑coding “master” branch in GitHub links.

Use HEAD to be branch‑agnostic.

-https://github.com/asyncapi/spec/blob/master/spec/asyncapi.md - Latest specification source
+https://github.com/asyncapi/spec/blob/HEAD/spec/asyncapi.md - Latest specification source

---

67-75: Normalize URLs when concatenating base + slug.

Guard against missing/duplicate slashes by using URL().

-    posts.docs
+    posts.docs
       .sort((a, b) => (a.slug ?? '').localeCompare(b.slug ?? ''))
       .forEach((doc: any) => {
-        content += `${base}${doc.slug} - ${doc.title}\n`;
+        const href = new URL(doc.slug ?? '/', base).toString();
+        content += `${href} - ${doc.title}\n`;
       });

---

77-86: Handle missing/invalid dates in blog sort to avoid NaN comparator.

Current comparator can return NaN leading to unstable ordering.

-    posts.blog
-      .sort((a: any, b: any) => new Date(b.date).getTime() - new Date(a.date).getTime())
+    const toEpoch = (d?: string) => (d ? Date.parse(d) || 0 : 0);
+    posts.blog
+      .sort((a: any, b: any) => toEpoch(b.date) - toEpoch(a.date))
       .forEach((post: any) => {
-        const date = post.date ? ` (${post.date.split('T')[0]})` : '';
-        content += `${base}${post.slug} - ${post.title}${date}\n`;
+        const href = new URL(post.slug ?? '/', base).toString();
+        const date = post.date ? ` (${(post.date as string).split('T')[0]})` : '';
+        content += `${href} - ${post.title}${date}\n`;
       });

---

88-94: Stabilize About page order.

Sort for deterministic output.

-    posts.about.forEach((page: any) => {
-      content += `${base}${page.slug} - ${page.title}\n`;
-    });
+    posts.about
+      .sort((a: any, b: any) => (a.slug ?? '').localeCompare(b.slug ?? ''))
+      .forEach((page: any) => {
+        const href = new URL(page.slug ?? '/', base).toString();
+        content += `${href} - ${page.title}\n`;
+      });

---

96-108: Dynamic sections: type‑safety and deterministic order.

Avoid any and keep sorting consistent.

-  Object.keys(posts).forEach((postType) => {
+  (Object.keys(posts) as string[]).forEach((postType) => {
     if (!['docs', 'blog', 'about', 'docsTree'].includes(postType)) {
-      const postArray = (posts as any)[postType];
-      if (Array.isArray(postArray) && postArray.length > 0) {
+      const postArray = (posts as any)[postType];
+      if (Array.isArray(postArray) && postArray.length > 0) {
         const sectionTitle = postType.charAt(0).toUpperCase() + postType.slice(1);
         content += `\n## ${sectionTitle}\n`;
-        postArray.forEach((item: any) => {
-          content += `${base}${item.slug} - ${item.title}\n`;
-        });
+        postArray
+          .sort((a: any, b: any) => (a.slug ?? '').localeCompare(b.slug ?? ''))
+          .forEach((item: any) => {
+            const href = new URL(item.slug ?? '/', base).toString();
+            content += `${href} - ${item.title}\n`;
+          });
       }
     }
   });

---

127-130: Avoid hard‑coded “master” in example links.

Prefer HEAD to survive default‑branch changes.

-https://github.com/asyncapi/asyncapi/tree/master/examples - Official AsyncAPI document examples
-https://github.com/asyncapi/spec/tree/master/examples - Specification examples
+https://github.com/asyncapi/asyncapi/tree/HEAD/examples - Official AsyncAPI document examples
+https://github.com/asyncapi/spec/tree/HEAD/examples - Specification examples

Confirm the first link actually has an examples folder; if not, drop it and keep only the spec repo.

---

135-139: Use a public Slack join URL instead of workspace URL.

Direct workspace URL often requires being logged in.

-https://asyncapi.slack.com - Official Slack community
+https://www.asyncapi.com/slack - Official Slack community

---

143-151: Robust URL counting and path resolution for output.

Count actual URLs (regex) and write using an absolute path relative to this script to avoid CWD issues.

-  // Calculate URL count after all content is assembled
-  const urlCount = content.split('\n').filter((line) => line.includes('http')).length;
+  // Calculate URL count after all content is assembled
+  const urlCount = (content.match(/\bhttps?:\/\/\S+/g) ?? []).length;
   content += `# Total URLs: ${urlCount}\n`;
 
-  // Ensure output dir exists and write the file
-  await fs.promises.mkdir('./public', { recursive: true });
-  await fs.promises.writeFile('./public/llms-full.txt', content, 'utf8');
-  console.log(`✅ llms-full.txt generated successfully with ${urlCount} URLs at ./public/llms-full.txt`);
+  // Ensure output dir exists and write the file (relative to repo, not CWD)
+  const outDir = resolve(dirname(fileURLToPath(import.meta.url)), '../public');
+  const outPath = resolve(outDir, 'llms-full.txt');
+  await fs.mkdir(outDir, { recursive: true });
+  await fs.writeFile(outPath, content, 'utf8');
+  console.log(`✅ llms-full.txt generated successfully with ${urlCount} URLs at ${outPath}`);

Configuration used: Path: .coderabbit.yaml

Review profile: CHILL

Plan: Pro

Learnt from: akshatnema
PR: asyncapi/website#3101
File: scripts/build-rss.js:4-6
Timestamp: 2024-11-01T09:35:23.912Z
Learning: Converting `getAllPosts()` to asynchronous in `scripts/build-rss.js` causes the existing build system to fail.

Learnt from: akshatnema
PR: asyncapi/website#3423
File: tests/index.test.js:2-7
Timestamp: 2025-01-18T08:44:43.614Z
Learning: In the AsyncAPI website project, JavaScript test files must include the .ts extension when importing TypeScript files (e.g., `require('../scripts/build-rss.ts')`). This is enforced by the project's configuration which uses `moduleResolution: "bundler"` in tsconfig.json and TypeScript-aware ESLint plugins. The .ts extensions are required even though the files are imported using CommonJS require statements.

Learnt from: vishvamsinh28
PR: asyncapi/website#3284
File: scripts/build-post-list.js:49-53
Timestamp: 2024-11-10T18:16:22.273Z
Learning: In `scripts/build-post-list.js`, the `walkDirectories` function depends on sequential execution because it mutates `resultObj`. Parallelizing the loop with `Promise.all` causes tests to fail.

Configuration used: Path: .coderabbit.yaml

Review profile: CHILL

Plan: Pro

tests/scripts/build-llms-full.test.ts (2)

7-7: Fix indentation for consistency.

The it block has extra leading spaces compared to other blocks in the test suite.

Apply this diff:

-    it('should write llms-full.txt with links', async () => {
+  it('should write llms-full.txt with links', async () => {

---

29-32: Consider verifying key content sections.

The test only checks for "Getting Started" but doesn't verify other critical sections like "Core Specifications", "AsyncAPI Complete Resources", or the structure of generated links. This would help catch regressions in the content format.

For example, add assertions like:

expect(content).toContain('# AsyncAPI Complete Resources');
expect(content).toContain('## Core Specifications');
expect(content).toContain('https://www.asyncapi.com/docs/getting-started');
expect(content).toContain('## Recent Blog Posts');
expect(content).toContain('[First Post](https://www.asyncapi.com/blog/1)');

tests/scripts/build-llms.test.ts (2)

7-7: Fix indentation for consistency.

The it block has extra leading spaces compared to other blocks in the test suite.

Apply this diff:

-    it('should write llms.txt to public directory', async () => {
+  it('should write llms.txt to public directory', async () => {

---

22-24: Consider verifying actual content instead of just type.

Since buildLlmsTxt() generates static content, the test could verify key sections and links to catch regressions in the file format.

For example, replace line 24 with specific content assertions:

const content = writeMock.mock.calls[0][1] as string;
expect(content).toContain('# AsyncAPI');
expect(content).toContain('## Core Resources');
expect(content).toContain('https://www.asyncapi.com/llms-full.txt');
expect(content).toContain('[Getting started guide](https://www.asyncapi.com/docs/getting-started)');
expect(content).toContain('Always prefer v3.0 specification over v2.x');

Configuration used: Path: .coderabbit.yaml

Review profile: CHILL

Plan: Pro

Learnt from: akshatnema
PR: asyncapi/website#3101
File: tests/build-rss.test.js:25-27
Timestamp: 2024-11-01T09:55:20.531Z
Learning: In `tests/build-rss.test.js`, replacing `jest.resetModules()` with `jest.resetAllMocks()` in the `afterEach()` block causes errors. It is necessary to use `jest.resetModules()` to reset the module registry between tests in this file.

tests/scripts/build-llms-full.test.ts (1)

7-33: Strengthen test coverage to verify content structure and format.

The current test only checks for the presence of 'Getting Started' in the output, which is insufficient to validate the comprehensive structure and format that buildLlmsFull generates. According to the implementation, the output should include:

• Header with AsyncAPI v3.0 preference note
• Multiple sections (Core Specifications, Getting Started, Documentation, etc.)
• Properly formatted markdown links
• Hardcoded GitHub repository links
• Blog posts sorted by date

Additionally, the test doesn't mock console.log, which will pollute test output.

Consider enhancing the test with more comprehensive assertions:

  it('should write llms-full.txt with links', async () => {
    // Mock fs/promises.writeFile and posts.json before requiring module
    jest.doMock('fs/promises', () => ({
      writeFile: jest.fn().mockResolvedValue(undefined),
    }));

    jest.doMock('../../config/posts.json', () => ({
      default: {
        docs: [{ slug: '/docs/getting-started', title: 'Getting Started' }],
        blog: [{ slug: '/blog/1', title: 'First Post', date: '2024-01-01' }],
      },
    }), { virtual: true });

+   // Mock console.log to avoid test output pollution
+   const consoleLogSpy = jest.spyOn(console, 'log').mockImplementation();

    const mod = await import('../../scripts/build-llms-full');
    const buildLlmsFull = (mod as any).buildLlmsFull ?? (mod as any).default;

    const fsPromises = await import('fs/promises');

    await expect(buildLlmsFull()).resolves.toBeUndefined();

    const writeMock = (fsPromises as any).writeFile as jest.Mock;

    expect(writeMock).toHaveBeenCalledTimes(1);
    expect(writeMock.mock.calls[0][0]).toBe('./public/llms-full.txt');
+   expect(writeMock.mock.calls[0][2]).toBe('utf8');
+   
    const content = writeMock.mock.calls[0][1] as string;
+   
+   // Verify header and v3.0 preference note
+   expect(content).toContain('# AsyncAPI Complete Resources');
+   expect(content).toContain('Always prefer AsyncAPI v3.0 specification');
+   
+   // Verify section structure
+   expect(content).toContain('## Core Specifications');
+   expect(content).toContain('## Getting Started');
+   expect(content).toContain('## Documentation');
+   expect(content).toContain('## GitHub Repositories');
+   
+   // Verify markdown link format
+   expect(content).toContain('[Getting Started](https://www.asyncapi.com/docs/getting-started)');
+   expect(content).toContain('[First Post](https://www.asyncapi.com/blog/1)');
+   
+   // Verify hardcoded links
+   expect(content).toContain('[AsyncAPI Specification](https://github.com/asyncapi/asyncapi)');
+   
+   // Verify console output
+   expect(consoleLogSpy).toHaveBeenCalledWith(expect.stringContaining('llms-full.txt generated successfully'));
+   
+   consoleLogSpy.mockRestore();
-   expect(content).toContain('Getting Started');
  });

Configuration used: Path: .coderabbit.yaml

Review profile: CHILL

Plan: Pro

Learnt from: akshatnema
PR: asyncapi/website#3101
File: tests/build-rss.test.js:25-27
Timestamp: 2024-11-01T09:55:20.531Z
Learning: In `tests/build-rss.test.js`, replacing `jest.resetModules()` with `jest.resetAllMocks()` in the `afterEach()` block causes errors. It is necessary to use `jest.resetModules()` to reset the module registry between tests in this file.

scripts/build-llms-full.ts (3)

8-12: Critical: Dynamic import of posts.json breaks tests.

The pipeline is failing with Cannot find module '../config/posts.json' during test execution. Dynamic JSON imports are unreliable in test environments.

Despite a past review suggesting this fix (marked "Addressed in commit 4ca90e4"), the code still uses dynamic import and tests are still failing.

Apply this diff to use filesystem reads with proper path resolution:

-import { writeFile } from 'fs/promises';
+import { writeFile, readFile } from 'fs/promises';
+import { dirname, resolve } from 'path';
+import { fileURLToPath } from 'url';

 import type { Result } from '@/types/scripts/build-posts-list';

 /**
  * Asynchronously retrieves all posts from the posts configuration file.
  */
 async function getAllPosts(): Promise<Result> {
-  const posts = (await import('../config/posts.json')).default as Result;
-
-  return posts;
+  const __filename = fileURLToPath(import.meta.url);
+  const __dirname = dirname(__filename);
+  const jsonPath = resolve(__dirname, '../config/posts.json');
+  const raw = await readFile(jsonPath, 'utf8');
+  return JSON.parse(raw) as Result;
 }

---

94-104: Update outdated GitHub repository URLs.

Multiple repository URLs need correction:

• Line 94: asyncapi/asyncapi should be asyncapi/spec (main specification repository)
• Line 96: asyncapi/parser is archived; link either to the archived repo explicitly or to current parser implementations
• Line 103: References asyncapi/asyncapi/tree/master/examples should use asyncapi/spec

These issues were identified in a past review but remain unaddressed.

Apply this diff to fix the repository links:

 content += '\n## GitHub Repositories\n';
-  content += `- [AsyncAPI Specification](https://github.com/asyncapi/asyncapi): Main specification repository
+  content += `- [AsyncAPI Specification](https://github.com/asyncapi/spec): Main specification repository
 - [AsyncAPI Generator](https://github.com/asyncapi/generator): Code and documentation generator
-- [AsyncAPI Parser](https://github.com/asyncapi/parser): AsyncAPI document parser library
+- [AsyncAPI Parser JS](https://github.com/asyncapi/parser-js): AsyncAPI document parser library (JavaScript)
 - [AsyncAPI CLI](https://github.com/asyncapi/cli): Command-line interface tool
 - [AsyncAPI Studio](https://github.com/asyncapi/studio): Visual AsyncAPI editor
 - [Modelina](https://github.com/asyncapi/modelina): Model/type generation library
 - [AsyncAPI Bindings](https://github.com/asyncapi/bindings): Protocol bindings specifications

 ## Examples and Templates
-- [Specification Examples](https://github.com/asyncapi/asyncapi/tree/master/examples): Official AsyncAPI document examples
+- [Specification Examples](https://github.com/asyncapi/spec/tree/master/examples): Official AsyncAPI document examples
 - [Template Examples](https://github.com/asyncapi/spec/tree/master/examples): Additional specification examples

---

113-125: Add type safety check to prevent runtime errors with non-array post types.

The loop assumes all post types are arrays, but Result includes docsTree which is a NavTree object. While the current code happens to fail safely (.length on object returns undefined), it should explicitly guard against non-array types.

Past review suggested this fix but it was not applied.

Apply this diff to add proper type guards:

   // Add other important resources from posts
   Object.keys(posts).forEach((postType) => {
-    if (!['docs', 'blog'].includes(postType)) {
+    if (!['docs', 'blog', 'docsTree'].includes(postType)) {
       const postArray = (posts as any)[postType];

-      if (postArray && postArray.length > 0) {
+      if (Array.isArray(postArray) && postArray.length > 0) {
         postArray.forEach((item: any) => {
           if (item.slug && item.title) {
             content += `- [${item.title}](${base}${item.slug})\n`;

scripts/build-llms-full.ts (1)

127-133: Consider ensuring output directory exists before writing.

The script writes to ./public/llms-full.txt without first ensuring the directory exists. While this likely works in practice (the public/ directory is created by other build steps), it's a best practice to ensure the directory exists for robustness.

Add directory creation before the write:

+  import { writeFile, mkdir } from 'fs/promises';
+
   // Write the file
+  await mkdir('./public', { recursive: true });
   await writeFile('./public/llms-full.txt', content, 'utf8');

Configuration used: Path: .coderabbit.yaml

Review profile: CHILL

Plan: Pro

scripts/build-llms-full.ts (3)

8-12: Critical: Dynamic import still failing in pipeline.

The pipeline reports Cannot find module '../config/posts.json'. Although a previous comment suggested using fs.promises.readFile with path resolution and was marked as addressed, the failure persists.

Apply the previously suggested fix using filesystem reads:

-import { writeFile } from 'fs/promises';
+import { writeFile, readFile } from 'fs/promises';
+import { dirname, resolve } from 'path';
+import { fileURLToPath } from 'url';

 import type { Result } from '@/types/scripts/build-posts-list';

 /**
  * Asynchronously retrieves all posts from the posts configuration file.
  */
 async function getAllPosts(): Promise<Result> {
-  const posts = (await import('../config/posts.json')).default as Result;
-
-  return posts;
+  const __filename = fileURLToPath(import.meta.url);
+  const __dirname = dirname(__filename);
+  const postsPath = resolve(__dirname, '../config/posts.json');
+  const raw = await readFile(postsPath, 'utf-8');
+  return JSON.parse(raw) as Result;
 }

---

133-141: Update GitHub repository links and remove duplicate.

Three issues:

1. Line 134: https://github.com/asyncapi/asyncapi redirects; use https://github.com/asyncapi/spec
2. Line 136: https://github.com/asyncapi/parser is archived; consider whether to link the archived repo or remove it
3. Line 140: "AsyncAPI Bindings" is already added at line 78 in the Core Specifications section

Apply this diff:

 content += '\n## GitHub Repositories\n';
-content += addLink('AsyncAPI Specification', 'https://github.com/asyncapi/asyncapi', 'Main specification repository');
+content += addLink('AsyncAPI Specification', 'https://github.com/asyncapi/spec', 'Main specification repository');
 content += addLink('AsyncAPI Generator', 'https://github.com/asyncapi/generator', 'Code and documentation generator');
-content += addLink('AsyncAPI Parser', 'https://github.com/asyncapi/parser', 'AsyncAPI document parser library');
 content += addLink('AsyncAPI CLI', 'https://github.com/asyncapi/cli', 'Command-line interface tool');
 content += addLink('AsyncAPI Studio', 'https://github.com/asyncapi/studio', 'Visual AsyncAPI editor');
 content += addLink('Modelina', 'https://github.com/asyncapi/modelina', 'Model/type generation library');
-content += addLink('AsyncAPI Bindings', 'https://github.com/asyncapi/bindings', 'Protocol bindings specifications');

---

159-172: Add proper filtering and array type checking.

The loop should exclude about (already in Optional section) and docsTree (a NavTree object, not an array). Also verify the value is an array before treating it as one.

Apply this diff:

 // Add other important resources from posts
 Object.keys(posts).forEach((postType) => {
-  if (!['docs', 'blog'].includes(postType)) {
+  if (!['docs', 'blog', 'about', 'docsTree'].includes(postType)) {
     const postArray = (posts as any)[postType];

-    if (postArray && postArray.length > 0) {
+    if (Array.isArray(postArray) && postArray.length > 0) {
       postArray.forEach((item: any) => {
         if (item.slug && item.title) {
           content += addLinkFromSlug(item);

Configuration used: Path: .coderabbit.yaml

Review profile: CHILL

Plan: Pro

public/llms-full.txt (1)

106-108: Regenerate this file after fixing the generator script.

The generated output contains outdated GitHub repository URLs that originated from the generator script:

• Line 106: asyncapi/asyncapi should be asyncapi/spec
• Line 108: asyncapi/parser may be outdated

Once you fix the repository URLs in scripts/build-llms-full.ts (as noted in comments on that file), regenerate this file to reflect the corrections.

scripts/build-llms-full.ts (4)

160-172: Add type guard to prevent iterating over non-array properties.

The loop assumes every posts[postType] is an array, but the Result type includes docsTree: NavTree which is an object. Without a proper type guard, this code may attempt to iterate over non-array properties.

Apply this diff to add proper guards:

   // Add other important resources from posts
   Object.keys(posts).forEach((postType) => {
-    if (!['docs', 'blog'].includes(postType)) {
+    if (!['docs', 'blog', 'about', 'docsTree'].includes(postType)) {
       const postArray = (posts as any)[postType];

-      if (postArray && postArray.length > 0) {
+      if (Array.isArray(postArray) && postArray.length > 0) {
         postArray.forEach((item: any) => {
           if (item.slug && item.title) {
             content += addLinkFromSlug(item);
           }
         });
       }
     }
   });

Based on learnings

---

8-12: Fix the pipeline failure: use fs-based JSON loading instead of dynamic import.

The dynamic import of ../config/posts.json is causing a ModuleNotFoundError during test execution. This approach is unreliable in different execution contexts.

Apply this diff to use filesystem-based loading with proper path resolution:

 import { writeFile } from 'fs/promises';
+import { readFile } from 'fs/promises';
+import { dirname, resolve } from 'path';
+import { fileURLToPath } from 'url';

 import type { Result } from '@/types/scripts/build-posts-list';

 /**
  * Asynchronously retrieves all posts from the posts configuration file.
  */
 async function getAllPosts(): Promise<Result> {
-  const posts = (await import('../config/posts.json')).default as Result;
-
-  return posts;
+  const __filename = fileURLToPath(import.meta.url);
+  const __dirname = dirname(__filename);
+  const jsonPath = resolve(__dirname, '../config/posts.json');
+  const raw = await readFile(jsonPath, 'utf8');
+  return JSON.parse(raw) as Result;
 }

---

184-186: Ensure output directory exists before writing file.

The script writes to ./public/llms-full.txt without ensuring the public directory exists, which will cause a failure if the directory is missing.

Apply this diff:

+  // Ensure output directory exists
+  await writeFile('./public/llms-full.txt', content, 'utf8').catch(async (err) => {
+    if (err.code === 'ENOENT') {
+      const { mkdir } = await import('fs/promises');
+      await mkdir('./public', { recursive: true });
+      await writeFile('./public/llms-full.txt', content, 'utf8');
+    } else {
+      throw err;
+    }
+  });
-  // Write the file
-  await writeFile('./public/llms-full.txt', content, 'utf8');

Or more simply, always ensure the directory exists:

+  const { mkdir } = await import('fs/promises');
+  await mkdir('./public', { recursive: true });
   // Write the file
   await writeFile('./public/llms-full.txt', content, 'utf8');

---

134-136: Update outdated GitHub repository URLs.

Two repository links are outdated:

• Line 134: asyncapi/asyncapi has moved to asyncapi/spec
• Line 136: asyncapi/parser may redirect or be archived

Apply this diff:

-  content += addLink('AsyncAPI Specification', 'https://github.com/asyncapi/asyncapi', 'Main specification repository');
+  content += addLink('AsyncAPI Specification', 'https://github.com/asyncapi/spec', 'Main specification repository');
   content += addLink('AsyncAPI Generator', 'https://github.com/asyncapi/generator', 'Code and documentation generator');
-  content += addLink('AsyncAPI Parser', 'https://github.com/asyncapi/parser', 'AsyncAPI document parser library');
+  content += addLink('AsyncAPI Parser', 'https://github.com/asyncapi/parser-js', 'AsyncAPI document parser library');

Configuration used: Path: .coderabbit.yaml

Review profile: CHILL

Plan: Pro

scripts/build-llms-full.ts (2)

155-167: Add Array.isArray check to prevent potential runtime errors.

The code iterates over all post types but doesn't verify that the value is actually an array. The Result type includes docsTree: NavTree which is not an array and could cause issues if processed here.

Apply this diff:

   // Add other important resources from posts
   Object.keys(posts).forEach((postType) => {
-    if (!['docs', 'blog'].includes(postType)) {
+    if (!['docs', 'blog', 'docsTree'].includes(postType)) {
       const postArray = (posts as any)[postType];
 
-      if (postArray && postArray.length > 0) {
+      if (Array.isArray(postArray) && postArray.length > 0) {
         postArray.forEach((item: any) => {
           if (item.slug && item.title) {
             content += addLinkFromSlug(item);
           }
         });
       }
     }
   });

---

8-12: Fix the pipeline failure: replace dynamic import with fs.readFile.

The pipeline is failing because dynamic JSON imports don't work reliably in test environments. Use filesystem reading with path resolution instead.

Apply this diff:

+import { readFile } from 'fs/promises';
+import { dirname, resolve } from 'path';
+import { fileURLToPath } from 'url';
+
 /**
  * Asynchronously retrieves all posts from the posts configuration file.
  */
 async function getAllPosts(): Promise<Result> {
-  const posts = (await import('../config/posts.json')).default as Result;
+  const __filename = fileURLToPath(import.meta.url);
+  const __dirname = dirname(__filename);
+  const jsonPath = resolve(__dirname, '../config/posts.json');
+  const raw = await readFile(jsonPath, 'utf8');
+  const posts = JSON.parse(raw) as Result;
 
   return posts;
 }

scripts/build-llms-full.ts (1)

179-187: Consider ensuring the output directory exists.

While the ./public directory likely exists in the build environment, adding mkdir -p semantics would make the script more robust if run independently.

Apply this diff:

+import { writeFile, mkdir } from 'fs/promises';
...
   // Write the file
+  await mkdir('./public', { recursive: true });
   await writeFile('./public/llms-full.txt', content, 'utf8');

Configuration used: Path: .coderabbit.yaml

Review profile: CHILL

Plan: Pro

public/llms-full.txt (1)

92-92: Minor: Consider hyphenating compound adjective in blog post title (line 92).

Static analysis suggests "Open Source Climb" should use a hyphen when acting as a compound adjective: "Open-Source Climb." However, since this is a direct quote of a published blog post title, verify whether preserving the exact original title is preferred or if alignment with grammar conventions is desired.

Configuration used: Path: .coderabbit.yaml

Review profile: CHILL

Plan: Pro